/**
 * 代码生成器类
 * 负责根据配置生成ESP-IDF项目代码
 */

export class CodeGenerator {
    constructor(state) {
        this.state = state;
    }

    /**
     * 生成完整项目
     * @returns {Object} 项目文件对象
     */
    generateProject() {
        const files = {};
        
        // 生成主程序代码
        files['main/app_main.c'] = this.generateMainCode();
        files['main/user_config.h'] = this.generateConfigHeader();
        files['main/user_gpio.c'] = this.generateGPIOCode();
        files['main/user_gpio.h'] = this.generateGPIOHeader();
        
        // 生成WiFi相关文件（如果启用）
        const features = this.state.getFeatures();
        if (features.wifi) {
            files['main/user_wifi.c'] = this.generateWiFiCode();
            files['main/user_wifi.h'] = this.generateWiFiHeader();
        }
        
        // 生成MQTT相关文件（如果启用）
        if (features.mqtt) {
            files['main/user_mqtt.c'] = this.generateMQTTCode();
            files['main/user_mqtt.h'] = this.generateMQTTHeader();
        }
        
        // 生成主模块CMakeLists.txt
        files['main/CMakeLists.txt'] = this.generateMainCMakeLists();
        
        // 生成DHT11驱动组件（如果配置了DHT11引脚）
        const pinConfigs = this.state.getPinConfigurations();
        let hasDHT11 = false;
        for (const pin in pinConfigs) {
            const config = pinConfigs[pin];
            if (config.mode === 'dht11') {
                hasDHT11 = true;
                break;
            }
        }
        
        if (hasDHT11) {
            files['components/driver_dht11/dht11.c'] = this.generateDHT11Code();
            files['components/driver_dht11/dht11.h'] = this.generateDHT11Header();
            files['components/driver_dht11/CMakeLists.txt'] = this.generateDHT11CMakeLists();
        }
        
        // 生成工具组件
        files['components/utils/log_utils.c'] = this.generateLogUtilsCode();
        files['components/utils/log_utils.h'] = this.generateLogUtilsHeader();
        files['components/utils/mem_utils.c'] = this.generateMemUtilsCode();
        files['components/utils/mem_utils.h'] = this.generateMemUtilsHeader();
        files['components/utils/CMakeLists.txt'] = this.generateUtilsCMakeLists();
        
        // 生成配置文件
        files['config/sdkconfig.defaults'] = this.generateSdkConfigDefaults();
        files['config/Kconfig.projbuild'] = this.generateKconfigProjbuild();
        
        // 生成分区表
        files['partition_table/partition_table.csv'] = this.generatePartitionTable();
        
        // 生成脚本文件
        files['scripts/flash_script.sh'] = this.generateFlashScript();
        
        // 生成根目录文件
        files['CMakeLists.txt'] = this.generateRootCMakeLists();
        files['README.md'] = this.generateReadme();
        files['sdkconfig'] = this.generateSdkConfig();
        files['.gitignore'] = this.generateGitIgnore();
        
        return files;
    }

    /**
     * 生成主程序代码
     * @returns {string} app_main.c文件内容
     */
    generateMainCode() {
        const chipModel = this.state.getChipModel();
        const projectName = this.state.getProjectName();
        const features = this.state.getFeatures();
        const pinConfigurations = this.state.getPinConfigurations();
        const ledPin = this.state.getLedPin();
        const dht11Pin = this.state.getDht11Pin();
        
        let code = `/**
 * @file app_main.c
 * @brief ESP32项目主程序入口
 *
 * ESP32项目主程序，包含初始化流程和任务创建。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "user_config.h"
#include "user_gpio.h"
`;

        if (features.wifi) {
            code += `#include "user_wifi.h"
#include "nvs_flash.h"
`;
        }

        if (features.mqtt) {
            code += `#include "user_mqtt.h"
`;
        }

        // 检查是否有DHT11传感器
        let hasDHT11 = false;
        for (const pin in pinConfigurations) {
            const config = pinConfigurations[pin];
            if (config.mode === 'dht11') {
                hasDHT11 = true;
                break;
            }
        }
        
        if (hasDHT11) {
            code += `#include "dht11.h"
`;
        }

        code += `
static const char *TAG = "app_main";

void app_main(void)
{
    ESP_LOGI(TAG, "Hello from ${projectName}!");
    ESP_LOGI(TAG, "芯片型号: ${chipModel}");
    
    // 初始化GPIO
    user_gpio_init();
    ESP_LOGI(TAG, "GPIO初始化完成，LED引脚: ${ledPin}");
    
`;

        // 添加DHT11初始化代码
        if (hasDHT11) {
            code += `    // 初始化DHT11传感器
    dht11_init(${dht11Pin});
    ESP_LOGI(TAG, "DHT11传感器初始化完成，引脚: ${dht11Pin}");
    
`;
        }

        // 添加WiFi初始化代码
        if (features.wifi) {
            code += `    // WiFi初始化
    ESP_ERROR_CHECK(nvs_flash_init());
    user_wifi_init();
    
    // 等待WiFi连接
    if (user_wifi_wait_for_connection(pdMS_TO_TICKS(10000))) {
        ESP_LOGI(TAG, "WiFi连接成功");
    } else {
        ESP_LOGE(TAG, "WiFi连接失败");
    }
    
`;
        }

        // 添加MQTT初始化
        if (features.mqtt) {
            code += `    // MQTT初始化
    user_mqtt_init();
    
`;
        }

        code += `    // 主循环
    while (1) {
        // 切换LED状态
        user_led_toggle();
        ESP_LOGI(TAG, "LED状态切换");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
`;

        return code;
    }

    /**
     * 生成配置头文件
     * @returns {string} user_config.h文件内容
     */
    generateConfigHeader() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        const features = this.state.getFeatures();
        const ledPin = this.state.getLedPin();
        const dht11Pin = this.state.getDht11Pin();
        
        let config = `/**
 * @file user_config.h
 * @brief 用户配置头文件
 *
 * 包含项目配置的宏定义和参数声明。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#ifndef USER_CONFIG_H
#define USER_CONFIG_H

// 引脚配置
#define LED_PIN ${ledPin}
#define DHT11_PIN ${dht11Pin}

`;

        // 功能开关配置
        if (features.wifi) {
            config += `#define ENABLE_WIFI\n`;
        }
        
        if (features.mqtt) {
            config += `#define ENABLE_MQTT\n`;
        }
        
        if (features.ota) {
            config += `#define ENABLE_OTA\n`;
        }

        config += `
#endif /* USER_CONFIG_H */
`;

        return config;
    }

    /**
     * 生成GPIO头文件
     * @returns {string} user_gpio.h文件内容
     */
    generateGPIOHeader() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        
        return `/**
 * @file user_gpio.h
 * @brief GPIO驱动头文件
 *
 * 声明GPIO驱动相关的函数和数据结构。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#ifndef USER_GPIO_H
#define USER_GPIO_H

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief 初始化GPIO
 * 
 * 配置LED引脚为输出模式。
 */
void user_gpio_init(void);

/**
 * @brief 点亮LED
 * 
 * 设置LED引脚为高电平。
 */
void user_led_on(void);

/**
 * @brief 熄灭LED
 * 
 * 设置LED引脚为低电平。
 */
void user_led_off(void);

/**
 * @brief 切换LED状态
 * 
 * 切换LED引脚的电平状态。
 */
void user_led_toggle(void);

#ifdef __cplusplus
}
#endif

#endif /* USER_GPIO_H */
`;
    }

    /**
     * 生成GPIO实现文件
     * @returns {string} user_gpio.c文件内容
     */
    generateGPIOCode() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        const ledPin = this.state.getLedPin();
        
        return `/**
 * @file user_gpio.c
 * @brief GPIO驱动实现
 *
 * 实现GPIO初始化和LED控制功能。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#include "user_gpio.h"
#include "user_config.h"
#include "driver/gpio.h"

static int led_state = 0;

void user_gpio_init(void)
{
    // 配置LED引脚为输出模式
    gpio_reset_pin(LED_PIN);
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
    gpio_set_level(LED_PIN, 0);
}

void user_led_on(void)
{
    gpio_set_level(LED_PIN, 1);
    led_state = 1;
}

void user_led_off(void)
{
    gpio_set_level(LED_PIN, 0);
    led_state = 0;
}

void user_led_toggle(void)
{
    if (led_state) {
        user_led_off();
    } else {
        user_led_on();
    }
}
`;
    }

    /**
     * 生成WiFi头文件
     * @returns {string} user_wifi.h文件内容
     */
    generateWiFiHeader() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        
        return `/**
 * @file user_wifi.h
 * @brief WiFi功能头文件
 *
 * 声明WiFi功能相关的函数和数据结构。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#ifndef USER_WIFI_H
#define USER_WIFI_H

#include <stdbool.h>
#include "freertos/FreeRTOS.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief 初始化WiFi
 * 
 * 初始化WiFi模块，创建网络接口并启动连接过程。
 */
void user_wifi_init(void);

/**
 * @brief 等待WiFi连接
 * 
 * 等待WiFi连接成功或超时。
 * 
 * @param ticks_to_wait 等待的ticks数
 * @return bool true表示连接成功，false表示超时或失败
 */
bool user_wifi_wait_for_connection(TickType_t ticks_to_wait);

/**
 * @brief 检查WiFi连接状态
 * 
 * @return bool true表示已连接，false表示未连接
 */
bool user_wifi_is_connected(void);

/**
 * @brief 断开WiFi连接
 * 
 * 主动断开WiFi连接。
 */
void user_wifi_disconnect(void);

/**
 * @brief 重新连接WiFi
 * 
 * 重新连接到WiFi网络。
 */
void user_wifi_reconnect(void);

#ifdef __cplusplus
}
#endif

#endif /* USER_WIFI_H */
`;
    }

    /**
     * 生成WiFi实现文件
     * @returns {string} user_wifi.c文件内容
     */
    generateWiFiCode() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        
        return `/**
 * @file user_wifi.c
 * @brief WiFi功能实现
 *
 * 实现WiFi连接、重连和状态管理功能。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#include "user_wifi.h"
#include "user_config.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "freertos/event_groups.h"

static const char *TAG = "user_wifi";

static EventGroupHandle_t wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1

static int s_retry_num = 0;
static const int WIFI_MAXIMUM_RETRY = 5;
static bool wifi_connected = false;

static void event_handler(void* arg, esp_event_base_t event_base,
                         int32_t event_id, void* event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < WIFI_MAXIMUM_RETRY) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGI(TAG, "重连WiFi AP");
        } else {
            xEventGroupSetBits(wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGI(TAG,"连接失败");
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "获得IP地址:" IPSTR, IP2STR(&event->ip_info.ip));
        s_retry_num = 0;
        wifi_connected = true;
        xEventGroupSetBits(wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void user_wifi_init(void)
{
    wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_got_ip));
                                                        
    // 启动WiFi
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
}

bool user_wifi_wait_for_connection(TickType_t ticks_to_wait)
{
    EventBits_t bits = xEventGroupWaitBits(wifi_event_group,
            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
            pdFALSE,
            pdFALSE,
            ticks_to_wait);

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "WiFi连接成功");
        return true;
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGE(TAG, "WiFi连接失败");
        return false;
    } else {
        ESP_LOGE(TAG, "WiFi连接超时");
        return false;
    }
}

bool user_wifi_is_connected(void)
{
    return wifi_connected;
}

void user_wifi_disconnect(void)
{
    esp_wifi_disconnect();
    wifi_connected = false;
    ESP_LOGI(TAG, "WiFi已断开");
}

void user_wifi_reconnect(void)
{
    s_retry_num = 0;
    esp_wifi_connect();
    ESP_LOGI(TAG, "正在重新连接WiFi");
}
`;
    }

    /**
     * 生成MQTT头文件
     * @returns {string} user_mqtt.h文件内容
     */
    generateMQTTHeader() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        
        return `/**
 * @file user_mqtt.h
 * @brief MQTT客户端头文件
 *
 * 声明MQTT客户端相关的函数和数据结构。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#ifndef USER_MQTT_H
#define USER_MQTT_H

#include <stdbool.h>
#include "esp_err.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief 初始化MQTT客户端
 * 
 * 创建并配置MQTT客户端，启动连接过程。
 */
void user_mqtt_init(void);

/**
 * @brief 发布MQTT消息
 * 
 * @param topic 主题
 * @param data 数据
 * @return esp_err_t ESP_OK表示成功，其他表示失败
 */
esp_err_t user_mqtt_publish(const char *topic, const char *data);

/**
 * @brief 检查MQTT连接状态
 * 
 * @return bool true表示已连接，false表示未连接
 */
bool user_mqtt_is_connected(void);

/**
 * @brief 断开MQTT连接
 * 
 * 主动断开MQTT连接。
 */
void user_mqtt_disconnect(void);

#ifdef __cplusplus
}
#endif

#endif /* USER_MQTT_H */
`;
    }

    /**
     * 生成MQTT实现文件
     * @returns {string} user_mqtt.c文件内容
     */
    generateMQTTCode() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        
        return `/**
 * @file user_mqtt.c
 * @brief MQTT客户端实现
 *
 * 实现MQTT连接、订阅、消息发布和回调处理。
 * 
 * 项目名称: ${projectName}
 * 芯片型号: ${chipModel}
 * 生成时间: ${new Date().toLocaleString('zh-CN')}
 */

#include "user_mqtt.h"
#include "user_config.h"
#include "esp_log.h"
#include "mqtt_client.h"

static const char *TAG = "user_mqtt";
static esp_mqtt_client_handle_t client;

static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
    esp_mqtt_event_handle_t event = event_data;
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT连接成功");
        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT断开连接");
        break;
    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT订阅成功, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT取消订阅, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT发布成功, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "MQTT收到数据 topic=%.*s data=%.*s",
                 event->topic_len, event->topic,
                 event->data_len, event->data);
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGI(TAG, "MQTT错误");
        break;
    default:
        ESP_LOGI(TAG, "MQTT事件ID:%d", event->event_id);
        break;
    }
}

void user_mqtt_init(void)
{
    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = "mqtt://test.mosquitto.org",
    };
    
    client = esp_mqtt_client_init(&mqtt_cfg);
    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
    esp_mqtt_client_start(client);
}

esp_err_t user_mqtt_publish(const char* topic, const char* data)
{
    int msg_id = esp_mqtt_client_publish(client, topic, data, 0, 1, 0);
    ESP_LOGI(TAG, "发送消息成功, msg_id=%d", msg_id);
    return ESP_OK;
}

bool user_mqtt_is_connected(void)
{
    // 简化实现，实际应用中可能需要更复杂的连接状态检查
    return client != NULL;
}

void user_mqtt_disconnect(void)
{
    if (client) {
        esp_mqtt_client_stop(client);
    }
}
`;
    }

    /**
     * 生成主模块CMakeLists.txt
     * @returns {string} CMakeLists.txt文件内容
     */
    generateMainCMakeLists() {
        return `# 主模块CMakeLists.txt
# 定义主程序模块的编译配置

idf_component_register(
    SRCS 
        "app_main.c"
        "user_gpio.c"
        "user_wifi.c"
        "user_mqtt.c"
    INCLUDE_DIRS 
        "."
    REQUIRES 
        nvs_flash
        esp_wifi
        protocol_examples_common
        mqtt
        log
        driver
        utils
        driver_dht11
)
`;
    }

    /**
     * 生成DHT11驱动头文件
     * @returns {string} dht11.h文件内容
     */
    generateDHT11Header() {
        return `/**
 * @file dht11.h
 * @brief DHT11传感器驱动头文件
 *
 * 声明DHT11温湿度传感器驱动相关的函数和数据结构。
 */

#ifndef DHT11_H
#define DHT11_H

#include <stdint.h>
#include "esp_err.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief DHT11传感器数据结构
 */
typedef struct {
    uint8_t humidity_integral;      ///< 湿度整数部分
    uint8_t humidity_decimal;       ///< 湿度小数部分
    uint8_t temperature_integral;   ///< 温度整数部分
    uint8_t temperature_decimal;    ///< 温度小数部分
    uint8_t checksum;               ///< 校验和
} dht11_data_t;

/**
 * @brief 初始化DHT11传感器
 * 
 * @param gpio_num DHT11数据引脚号
 */
void dht11_init(gpio_num_t gpio_num);

/**
 * @brief 读取DHT11传感器数据
 * 
 * @param data 存储读取数据的结构体指针
 * @return esp_err_t ESP_OK表示成功，其他表示失败
 */
esp_err_t dht11_read_data(dht11_data_t *data);

#ifdef __cplusplus
}
#endif

#endif /* DHT11_H */
`;
    }

    /**
     * 生成DHT11驱动实现文件
     * @returns {string} dht11.c文件内容
     */
    generateDHT11Code() {
        return `/**
 * @file dht11.c
 * @brief DHT11传感器驱动实现
 *
 * 实现DHT11温湿度传感器的数据读取功能。
 */

#include "dht11.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include "esp_log.h"

static const char *TAG = "dht11";
static gpio_num_t dht11_gpio_pin;

/**
 * @brief DHT11引脚输出模式设置
 * 
 * @param level 电平状态
 */
static void dht11_pin_output(uint32_t level)
{
    gpio_set_level(dht11_gpio_pin, level);
}

/**
 * @brief DHT11引脚输入模式设置
 */
static void dht11_pin_input(void)
{
    gpio_set_direction(dht11_gpio_pin, GPIO_MODE_INPUT);
}

/**
 * @brief 读取DHT11引脚电平
 * 
 * @return int 电平状态
 */
static int dht11_pin_read(void)
{
    return gpio_get_level(dht11_gpio_pin);
}

/**
 * @brief DHT11引脚初始化
 */
static void dht11_pin_init(void)
{
    gpio_reset_pin(dht11_gpio_pin);
    gpio_set_direction(dht11_gpio_pin, GPIO_MODE_INPUT_OUTPUT_OD);
    gpio_set_level(dht11_gpio_pin, 1);
}

void dht11_init(gpio_num_t gpio_num)
{
    dht11_gpio_pin = gpio_num;
    dht11_pin_init();
}

esp_err_t dht11_read_data(dht11_data_t *data)
{
    if (!data) {
        return ESP_ERR_INVALID_ARG;
    }

    uint8_t bits[5] = {0}; // 40位数据存储在5个字节中
    uint8_t cnt = 7;
    uint8_t idx = 0;

    // 开始信号：主机拉低至少18ms
    dht11_pin_output(0);
    vTaskDelay(pdMS_TO_TICKS(20));
    
    // 主机拉高20-40us，等待从机响应
    dht11_pin_output(1);
    ets_delay_us(30);
    
    // 设置为输入模式，等待从机拉低
    dht11_pin_input();
    
    // 等待从机拉低（约80us）
    uint32_t timeout = 0;
    while (dht11_pin_read() && timeout++ < 10000) {
        ets_delay_us(1);
    }
    
    if (timeout >= 10000) {
        ESP_LOGE(TAG, "DHT11未响应");
        return ESP_FAIL;
    }
    
    // 等待从机拉高（约80us）
    timeout = 0;
    while (!dht11_pin_read() && timeout++ < 10000) {
        ets_delay_us(1);
    }
    
    if (timeout >= 10000) {
        ESP_LOGE(TAG, "DHT11响应超时");
        return ESP_FAIL;
    }
    
    // 等待从机拉低（约80us）
    timeout = 0;
    while (dht11_pin_read() && timeout++ < 10000) {
        ets_delay_us(1);
    }
    
    if (timeout >= 10000) {
        ESP_LOGE(TAG, "DHT11数据开始超时");
        return ESP_FAIL;
    }
    
    // 读取40位数据
    for (int i = 0; i < 40; i++) {
        // 等待50us低电平结束
        timeout = 0;
        while (!dht11_pin_read() && timeout++ < 10000) {
            ets_delay_us(1);
        }
        
        if (timeout >= 10000) {
            ESP_LOGE(TAG, "DHT11数据位开始超时");
            return ESP_FAIL;
        }
        
        // 等待高电平结束，根据高电平持续时间判断是0还是1
        ets_delay_us(40);
        if (dht11_pin_read()) {
            // 高电平持续时间>30us表示位数据为1
            bits[idx] |= (1 << cnt);
        }
        
        // 等待剩余高电平时间结束
        timeout = 0;
        while (dht11_pin_read() && timeout++ < 10000) {
            ets_delay_us(1);
        }
        
        if (timeout >= 10000) {
            ESP_LOGE(TAG, "DHT11数据位结束超时");
            return ESP_FAIL;
        }
        
        if (cnt == 0) {
            cnt = 7;
            idx++;
        } else {
            cnt--;
        }
    }
    
    // 复位引脚
    dht11_pin_output(1);
    
    // 检查校验和
    if (bits[4] != ((bits[0] + bits[1] + bits[2] + bits[3]) & 0xFF)) {
        ESP_LOGE(TAG, "DHT11数据校验失败");
        return ESP_FAIL;
    }
    
    data->humidity_integral = bits[0];
    data->humidity_decimal = bits[1];
    data->temperature_integral = bits[2];
    data->temperature_decimal = bits[3];
    data->checksum = bits[4];
    
    return ESP_OK;
}
`;
    }

    /**
     * 生成DHT11驱动组件CMakeLists.txt
     * @returns {string} CMakeLists.txt文件内容
     */
    generateDHT11CMakeLists() {
        return `# DHT11驱动组件CMakeLists.txt
# 定义DHT11驱动组件的编译配置

idf_component_register(
    SRCS 
        "dht11.c"
    INCLUDE_DIRS 
        "."
    REQUIRES 
        driver
        log
        utils
)
`;
    }

    /**
     * 生成日志工具头文件
     * @returns {string} log_utils.h文件内容
     */
    generateLogUtilsHeader() {
        return `/**
 * @file log_utils.h
 * @brief 增强日志工具头文件
 *
 * 声明增强日志功能相关的函数和数据结构。
 */

#ifndef LOG_UTILS_H
#define LOG_UTILS_H

#include "esp_log.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief 初始化日志系统
 */
void log_utils_init(void);

/**
 * @brief 带时间戳的日志输出
 * 
 * @param tag 日志标签
 * @param level 日志级别
 * @param format 格式化字符串
 * @param ... 可变参数
 */
void log_with_timestamp(const char *tag, esp_log_level_t level, const char *format, ...);

#ifdef __cplusplus
}
#endif

#endif /* LOG_UTILS_H */
`;
    }

    /**
     * 生成日志工具实现文件
     * @returns {string} log_utils.c文件内容
     */
    generateLogUtilsCode() {
        return `/**
 * @file log_utils.c
 * @brief 增强日志工具实现
 *
 * 实现带时间戳和模块标识的增强日志功能。
 */

#include "log_utils.h"
#include "esp_timer.h"
#include <stdio.h>
#include <stdarg.h>

static const char *TAG = "log_utils";

void log_utils_init(void)
{
    ESP_LOGI(TAG, "日志系统初始化");
}

void log_with_timestamp(const char *tag, esp_log_level_t level, const char *format, ...)
{
    // 获取时间戳
    int64_t timestamp = esp_timer_get_time();
    int64_t seconds = timestamp / 1000000;
    int64_t milliseconds = (timestamp % 1000000) / 1000;
    
    // 格式化时间
    int hours = (seconds / 3600) % 24;
    int minutes = (seconds / 60) % 60;
    int secs = seconds % 60;
    
    char time_buffer[16];
    snprintf(time_buffer, sizeof(time_buffer), "%02d:%02d:%02d.%03d", 
             hours, minutes, secs, (int)milliseconds);
    
    // 格式化日志内容
    char log_buffer[256];
    va_list args;
    va_start(args, format);
    vsnprintf(log_buffer, sizeof(log_buffer), format, args);
    va_end(args);
    
    // 输出日志
    switch (level) {
        case ESP_LOG_ERROR:
            ESP_LOGE(tag, "[%s] %s", time_buffer, log_buffer);
            break;
        case ESP_LOG_WARN:
            ESP_LOGW(tag, "[%s] %s", time_buffer, log_buffer);
            break;
        case ESP_LOG_INFO:
            ESP_LOGI(tag, "[%s] %s", time_buffer, log_buffer);
            break;
        case ESP_LOG_DEBUG:
            ESP_LOGD(tag, "[%s] %s", time_buffer, log_buffer);
            break;
        case ESP_LOG_VERBOSE:
            ESP_LOGV(tag, "[%s] %s", time_buffer, log_buffer);
            break;
        default:
            ESP_LOGI(tag, "[%s] %s", time_buffer, log_buffer);
            break;
    }
}
`;
    }

    /**
     * 生成内存工具头文件
     * @returns {string} mem_utils.h文件内容
     */
    generateMemUtilsHeader() {
        return `/**
 * @file mem_utils.h
 * @brief 安全内存操作工具头文件
 *
 * 声明安全内存操作相关的函数和数据结构。
 */

#ifndef MEM_UTILS_H
#define MEM_UTILS_H

#include <stdlib.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @brief 安全内存分配
 * 
 * @param size 分配的内存大小
 * @param file 调用文件名
 * @param line 调用行号
 * @return void* 分配的内存指针，失败返回NULL
 */
void* safe_malloc(size_t size, const char* file, int line);

/**
 * @brief 安全内存释放
 * 
 * @param ptr 要释放的内存指针
 * @param file 调用文件名
 * @param line 调用行号
 */
void safe_free(void** ptr, const char* file, int line);

/**
 * @brief 检查内存指针是否有效
 * 
 * @param ptr 内存指针
 * @return bool true表示有效，false表示无效
 */
bool is_valid_pointer(void* ptr);

/**
 * @brief 获取当前内存使用统计
 * 
 * @return size_t 当前已分配的内存总量
 */
size_t get_memory_usage(void);

#ifdef __cplusplus
}
#endif

// 宏定义，方便使用
#define SAFE_MALLOC(size) safe_malloc(size, __FILE__, __LINE__)
#define SAFE_FREE(ptr) safe_free((void**)&(ptr), __FILE__, __LINE__)

#endif /* MEM_UTILS_H */
`;
    }

    /**
     * 生成内存工具实现文件
     * @returns {string} mem_utils.c文件内容
     */
    generateMemUtilsCode() {
        return `/**
 * @file mem_utils.c
 * @brief 安全内存操作工具实现
 *
 * 实现安全内存分配、释放和检查功能。
 */

#include "mem_utils.h"
#include "esp_log.h"
#include <string.h>

static const char *TAG = "mem_utils";
static size_t total_allocated = 0;

void* safe_malloc(size_t size, const char* file, int line)
{
    if (size == 0) {
        ESP_LOGW(TAG, "尝试分配0字节内存 %s:%d", file, line);
        return NULL;
    }
    
    void* ptr = malloc(size);
    if (ptr) {
        total_allocated += size;
        ESP_LOGD(TAG, "分配 %zu 字节内存 %s:%d, 总计: %zu", size, file, line, total_allocated);
    } else {
        ESP_LOGE(TAG, "内存分配失败 %s:%d, 请求大小: %zu", file, line, size);
    }
    
    return ptr;
}

void safe_free(void** ptr, const char* file, int line)
{
    if (ptr && *ptr) {
        free(*ptr);
        *ptr = NULL;
        ESP_LOGD(TAG, "释放内存 %s:%d", file, line);
    }
}

bool is_valid_pointer(void* ptr)
{
    // 简单检查指针是否为NULL
    return ptr != NULL;
}

size_t get_memory_usage(void)
{
    return total_allocated;
}
`;
    }

    /**
     * 生成工具组件CMakeLists.txt
     * @returns {string} CMakeLists.txt文件内容
     */
    generateUtilsCMakeLists() {
        return `# 工具组件CMakeLists.txt
# 定义工具组件的编译配置

idf_component_register(
    SRCS 
        "log_utils.c"
        "mem_utils.c"
    INCLUDE_DIRS 
        "."
    REQUIRES 
        log
)
`;
    }

    /**
     * 生成SDK配置默认值文件
     * @returns {string} sdkconfig.defaults文件内容
     */
    generateSdkConfigDefaults() {
        const chipModel = this.state.getChipModel();
        const features = this.state.getFeatures();
        
        let config = `# SDK配置默认值
# 生成时间: ${new Date().toLocaleString('zh-CN')}

CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
CONFIG_FREERTOS_HZ=100
CONFIG_LOG_DEFAULT_LEVEL_INFO=y
CONFIG_PARTITION_TABLE_SINGLE_APP=y
`;

        if (features.wifi) {
            config += `CONFIG_ESP_WIFI_ENABLED=y
CONFIG_LWIP_DHCP_MAX_NIP=3
CONFIG_WIFI_SSID="your_wifi_ssid"
CONFIG_WIFI_PASSWORD="your_wifi_password"
`;
        }

        if (features.mqtt) {
            config += `CONFIG_MQTT_ENABLED=y
`;
        }

        if (features.ota) {
            config += `CONFIG_OTA_UPDATES_ENABLED=y
CONFIG_OTA_NUM_CUSTOM_PARTS=2
CONFIG_PARTITION_TABLE_CUSTOM=y
`;
        }

        return config;
    }

    /**
     * 生成Kconfig.projbuild文件
     * @returns {string} Kconfig.projbuild文件内容
     */
    generateKconfigProjbuild() {
        const projectName = this.state.getProjectName();
        const features = this.state.getFeatures();
        
        let kconfig = `# ${projectName} 项目配置
# 生成时间: ${new Date().toLocaleString('zh-CN')}

menu "${projectName} Configuration"

config ESP32_${projectName.toUpperCase()}_ENABLED
    bool "Enable ${projectName}"
    default y
    help
        Enable ${projectName} project features.

`;

        // 添加功能模块配置选项
        if (features.wifi) {
            kconfig += `config ESP32_${projectName.toUpperCase()}_WIFI_ENABLED
    bool "Enable WiFi support"
    default y
    depends on ESP32_${projectName.toUpperCase()}_ENABLED
    help
        Enable WiFi functionality in ${projectName} project.

`;
        }

        if (features.mqtt) {
            kconfig += `config ESP32_${projectName.toUpperCase()}_MQTT_ENABLED
    bool "Enable MQTT support"
    default y
    depends on ESP32_${projectName.toUpperCase()}_ENABLED
    help
        Enable MQTT functionality in ${projectName} project.

`;
        }

        if (features.ota) {
            kconfig += `config ESP32_${projectName.toUpperCase()}_OTA_ENABLED
    bool "Enable OTA updates"
    default y
    depends on ESP32_${projectName.toUpperCase()}_ENABLED
    help
        Enable Over-The-Air updates in ${projectName} project.

`;
        }

        kconfig += `endmenu
`;

        return kconfig;
    }

    /**
     * 生成分区表文件
     * @returns {string} partition_table.csv文件内容
     */
    generatePartitionTable() {
        return `# ESP-IDF 分区表
# Name,   Type, SubType, Offset,  Size, Flags
nvs,      data, nvs,     0x9000,  0x6000,
phy_init, data, phy,     0xf000,  0x1000,
factory,  app,  factory, 0x10000, 1M,
ota_0,    app,  ota_0,   ,        1M,
ota_1,    app,  ota_1,   ,        1M,
`;
    }

    /**
     * 生成烧录脚本文件
     * @returns {string} flash_script.sh文件内容
     */
    generateFlashScript() {
        const projectName = this.state.getProjectName();
        
        return `#!/bin/bash
# ESP32 项目烧录脚本
# 项目名称: ${projectName}
# 生成时间: ${new Date().toLocaleString('zh-CN')}

# 默认端口和波特率
PORT="/dev/ttyUSB0"
BAUD_RATE=921600

# 解析命令行参数
while [[ $# -gt 0 ]]; do
    case $1 in
        -p|--port)
            PORT="$2"
            shift 2
            ;;
        -b|--baud)
            BAUD_RATE="$2"
            shift 2
            ;;
        -h|--help)
            echo "用法: $0 [选项]"
            echo "选项:"
            echo "  -p, --port PORT     指定串口设备 (默认: /dev/ttyUSB0)"
            echo "  -b, --baud BAUD     指定波特率 (默认: 921600)"
            echo "  -h, --help          显示帮助信息"
            exit 0
            ;;
        *)
            echo "未知选项: $1"
            exit 1
            ;;
    esac
done

echo "正在烧录 ${projectName} 到设备..."
echo "端口: $PORT"
echo "波特率: $BAUD_RATE"

# 检查idf.py是否可用
if ! command -v idf.py &> /dev/null; then
    echo "错误: 未找到idf.py，请先设置ESP-IDF环境"
    exit 1
fi

# 执行烧录命令
idf.py -p $PORT -b $BAUD_RATE flash monitor

echo "烧录完成"
`;
    }

    /**
     * 生成根目录CMakeLists.txt文件
     * @returns {string} CMakeLists.txt文件内容
     */
    generateRootCMakeLists() {
        const projectName = this.state.getProjectName();
        
        return `# 项目级CMakeLists.txt
# 项目名称: ${projectName}
# 生成时间: ${new Date().toLocaleString('zh-CN')}

cmake_minimum_required(VERSION 3.16)

# 包含ESP-IDF构建系统
include($ENV{IDF_PATH}/tools/cmake/project.cmake)

# 设置项目名称
project(${projectName})

# 指定额外的组件目录
set(EXTRA_COMPONENT_DIRS 
    components
    components/driver_dht11
    components/utils
)

# 设置默认分区表文件
set(PARTITION_TABLE_CUSTOM_FILENAME \${CMAKE_SOURCE_DIR}/partition_table/partition_table.csv)
`;
    }

    /**
     * 生成.gitignore文件
     * @returns {string} .gitignore文件内容
     */
    generateGitIgnore() {
        return `# ESP-IDF构建输出
build/
sdkconfig.old
sdkconfig.new

# IDE配置
.vscode/
.idea/

# 编译器和调试器文件
*.o
*.a
*.elf
*.bin
*.map

# 日志文件
*.log

# 临时文件
*.tmp
*.temp

# 操作系统文件
.DS_Store
Thumbs.db

# Git相关
.git/
`;
    }

    /**
     * 生成README.md文件
     * @returns {string} README.md文件内容
     */
    generateReadme() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        const features = this.state.getFeatures();
        const ledPin = this.state.getLedPin();
        const dht11Pin = this.state.getDht11Pin();
        
        return `# ${projectName}

这是一个基于ESP-IDF v5.0+的ESP32项目，包含GPIO控制、WiFi连接、MQTT通信和DHT11传感器驱动等功能。

## 项目结构

\`\`\`
${projectName}/
├── main/                   # 主程序目录
│   ├── app_main.c          # 入口文件（含初始化流程、任务创建）
│   ├── user_config.h       # 用户配置头文件（宏定义、参数声明）
│   ├── user_gpio.c/h       # GPIO驱动（含初始化、中断处理）
│   ├── user_wifi.c/h       # WiFi功能（STA/AP模式、重连逻辑）
│   ├── user_mqtt.c/h       # MQTT客户端（连接、订阅、消息回调）
│   └── CMakeLists.txt      # 主模块编译配置
├── components/             # 自定义组件目录
│   ├── driver_dht11/       # DHT11传感器驱动组件
│   │   ├── dht11.c/h       # 驱动代码（含数据校验、超时重试）
│   │   └── CMakeLists.txt
│   └── utils/              # 工具组件（日志、内存管理）
│       ├── log_utils.c/h   # 增强日志（带时间戳、模块标识）
│       ├── mem_utils.c/h   # 安全内存操作（动态内存检查、释放）
│       └── CMakeLists.txt
├── config/                 # 配置文件目录
│   ├── sdkconfig.defaults  # 默认配置（适配ESP32-WROOM-32/ESP32-C3）
│   └── Kconfig.projbuild   # 项目自定义配置项（可在menuconfig中调节）
├── partition_table/        # 分区表目录
│   └── partition_table.csv # 自定义分区（app、ota_0、ota_1、data分区）
├── scripts/                # 辅助脚本
│   └── flash_script.sh     # 一键烧录脚本（支持指定端口、波特率）
├── CMakeLists.txt          # 项目根编译配置（指定组件路径、SDK版本）
└── README.md               # 说明文档（编译步骤、功能说明、故障排查）
\`\`\`

## 功能特性

1. **GPIO控制**：LED控制和通用GPIO操作（LED引脚: ${ledPin}）
2. **WiFi连接**：支持STA模式，具备自动重连功能
3. **MQTT通信**：MQTT客户端实现，支持订阅和发布消息
4. **DHT11传感器**：温湿度传感器驱动（引脚: ${dht11Pin}）
5. **工具组件**：
   - 增强日志系统（带时间戳和模块标识）
   - 安全内存操作（内存分配检查和释放）
6. **OTA支持**：支持固件无线升级（需在menuconfig中启用）
7. **配置管理**：通过Kconfig.projbuild自定义项目配置

## 编译步骤

1. **设置ESP-IDF环境**：
   \`\`\`bash
   # 获取ESP-IDF
   git clone --recursive https://github.com/espressif/esp-idf.git
   
   # 切换到v5.0分支
   cd esp-idf
   git checkout v5.0
   git submodule update --init --recursive
   
   # 安装依赖
   ./install.sh
   
   # 设置环境变量
   . ./export.sh
   \`\`\`

2. **配置项目**：
   \`\`\`bash
   # 进入项目目录
   cd ${projectName}
   
   # 配置项目（可选）
   idf.py menuconfig
   \`\`\`

3. **编译项目**：
   \`\`\`bash
   idf.py build
   \`\`\`

4. **烧录固件**：
   \`\`\`bash
   idf.py flash
   \`\`\`

5. **查看日志**：
   \`\`\`bash
   idf.py monitor
   \`\`\`

## 使用一键烧录脚本

项目提供了一键烧录脚本，可以简化烧录过程：

\`\`\`bash
# 给脚本添加执行权限
chmod +x scripts/flash_script.sh

# 使用默认配置烧录
./scripts/flash_script.sh

# 指定端口和波特率
./scripts/flash_script.sh -p /dev/ttyUSB0 -b 921600
\`\`\`

## 项目配置

项目支持通过menuconfig进行配置：

\`\`\`bash
idf.py menuconfig
\`\`\`

主要配置项包括：
- WiFi SSID和密码
- MQTT服务器地址
- 各种功能模块的启用/禁用

## 故障排查

如果遇到问题，请参考以下解决方案：

1. **编译错误**：
   - 确保已正确设置ESP-IDF环境
   - 检查是否有缺失的依赖库

2. **烧录失败**：
   - 检查设备是否正确连接
   - 确认选择了正确的串口
   - 尝试降低波特率（如115200）

3. **运行时问题**：
   - 查看串口监视器输出
   - 检查电源连接是否稳定
   - 确认引脚配置是否正确

## 许可证

本项目为开源项目，遵循MIT许可证。
`;
    }

    /**
     * 生成sdkconfig文件
     * @returns {string} sdkconfig文件内容
     */
    generateSdkConfig() {
        const projectName = this.state.getProjectName();
        const chipModel = this.state.getChipModel();
        const features = this.state.getFeatures();
        
        let config = `# SDK配置文件
# 项目名称: ${projectName}
# 芯片型号: ${chipModel}
# 生成时间: ${new Date().toLocaleString('zh-CN')}

CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
CONFIG_FREERTOS_HZ=100
CONFIG_LOG_DEFAULT_LEVEL_INFO=y
CONFIG_PARTITION_TABLE_SINGLE_APP=y
`;

        if (features.wifi) {
            config += `CONFIG_ESP_WIFI_ENABLED=y
CONFIG_LWIP_DHCP_MAX_NIP=3
CONFIG_WIFI_SSID="your_wifi_ssid"
CONFIG_WIFI_PASSWORD="your_wifi_password"
`;
        }

        if (features.mqtt) {
            config += `CONFIG_MQTT_ENABLED=y
`;
        }

        if (features.ota) {
            config += `CONFIG_OTA_UPDATES_ENABLED=y
CONFIG_OTA_NUM_CUSTOM_PARTS=2
CONFIG_PARTITION_TABLE_CUSTOM=y
`;
        }

        return config;
    }
}